home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / fs.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  61KB  |  1,678 lines
  1. #ifndef _LINUX_FS_H
  2. #define _LINUX_FS_H
  3.  
  4. /*
  5.  * This file has definitions for some important file table
  6.  * structures etc.
  7.  */
  8.  
  9. #include <linux/config.h>
  10. #include <linux/limits.h>
  11. #include <linux/ioctl.h>
  12.  
  13. /*
  14.  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
  15.  * the file limit at runtime and only root can increase the per-process
  16.  * nr_file rlimit, so it's safe to set up a ridiculously high absolute
  17.  * upper limit on files-per-process.
  18.  *
  19.  * Some programs (notably those using select()) may have to be 
  20.  * recompiled to take full advantage of the new limits..  
  21.  */
  22.  
  23. /* Fixed constants first: */
  24. #undef NR_OPEN
  25. #define NR_OPEN (1024*1024)    /* Absolute upper limit on fd num */
  26. #define INR_OPEN 1024        /* Initial setting for nfile rlimits */
  27.  
  28. #define BLOCK_SIZE_BITS 10
  29. #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
  30.  
  31. /* And dynamically-tunable limits and defaults: */
  32. struct files_stat_struct {
  33.     int nr_files;        /* read only */
  34.     int nr_free_files;    /* read only */
  35.     int max_files;        /* tunable */
  36. };
  37. extern struct files_stat_struct files_stat;
  38.  
  39. struct inodes_stat_t {
  40.     int nr_inodes;
  41.     int nr_unused;
  42.     int dummy[5];
  43. };
  44. extern struct inodes_stat_t inodes_stat;
  45.  
  46. extern int leases_enable, lease_break_time;
  47.  
  48. #ifdef CONFIG_DNOTIFY
  49. extern int dir_notify_enable;
  50. #endif
  51.  
  52. #define NR_FILE  8192    /* this can well be larger on a larger system */
  53.  
  54. #define MAY_EXEC 1
  55. #define MAY_WRITE 2
  56. #define MAY_READ 4
  57. #define MAY_APPEND 8
  58.  
  59. #define FMODE_READ 1
  60. #define FMODE_WRITE 2
  61.  
  62. /* Internal kernel extensions */
  63. #define FMODE_LSEEK    4
  64. #define FMODE_PREAD    8
  65. #define FMODE_PWRITE    FMODE_PREAD    /* These go hand in hand */
  66.  
  67. #define RW_MASK        1
  68. #define RWA_MASK    2
  69. #define READ 0
  70. #define WRITE 1
  71. #define READA 2        /* read-ahead  - don't block if no resources */
  72. #define SPECIAL 4    /* For non-blockdevice requests in request queue */
  73. #define READ_SYNC    (READ | (1 << BIO_RW_SYNC))
  74. #define WRITE_SYNC    (WRITE | (1 << BIO_RW_SYNC))
  75. #define WRITE_BARRIER    ((1 << BIO_RW) | (1 << BIO_RW_BARRIER))
  76.  
  77. #define SEL_IN        1
  78. #define SEL_OUT        2
  79. #define SEL_EX        4
  80.  
  81. /* public flags for file_system_type */
  82. #define FS_REQUIRES_DEV 1 
  83. #define FS_BINARY_MOUNTDATA 2
  84. #define FS_REVAL_DOT    16384    /* Check the paths ".", ".." for staleness */
  85. #define FS_ODD_RENAME    32768    /* Temporary stuff; will go away as soon
  86.                   * as nfs_rename() will be cleaned up
  87.                   */
  88. /*
  89.  * These are the fs-independent mount-flags: up to 32 flags are supported
  90.  */
  91. #define MS_RDONLY     1    /* Mount read-only */
  92. #define MS_NOSUID     2    /* Ignore suid and sgid bits */
  93. #define MS_NODEV     4    /* Disallow access to device special files */
  94. #define MS_NOEXEC     8    /* Disallow program execution */
  95. #define MS_SYNCHRONOUS    16    /* Writes are synced at once */
  96. #define MS_REMOUNT    32    /* Alter flags of a mounted FS */
  97. #define MS_MANDLOCK    64    /* Allow mandatory locks on an FS */
  98. #define MS_DIRSYNC    128    /* Directory modifications are synchronous */
  99. #define MS_NOATIME    1024    /* Do not update access times. */
  100. #define MS_NODIRATIME    2048    /* Do not update directory access times */
  101. #define MS_BIND        4096
  102. #define MS_MOVE        8192
  103. #define MS_REC        16384
  104. #define MS_VERBOSE    32768
  105. #define MS_POSIXACL    (1<<16)    /* VFS does not apply the umask */
  106. #define MS_ACTIVE    (1<<30)
  107. #define MS_NOUSER    (1<<31)
  108.  
  109. /*
  110.  * Superblock flags that can be altered by MS_REMOUNT
  111.  */
  112. #define MS_RMT_MASK    (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_NOATIME|\
  113.              MS_NODIRATIME)
  114.  
  115. /*
  116.  * Old magic mount flag and mask
  117.  */
  118. #define MS_MGC_VAL 0xC0ED0000
  119. #define MS_MGC_MSK 0xffff0000
  120.  
  121. /* Inode flags - they have nothing to superblock flags now */
  122.  
  123. #define S_SYNC        1    /* Writes are synced at once */
  124. #define S_NOATIME    2    /* Do not update access times */
  125. #define S_APPEND    4    /* Append-only file */
  126. #define S_IMMUTABLE    8    /* Immutable file */
  127. #define S_DEAD        16    /* removed, but still open directory */
  128. #define S_NOQUOTA    32    /* Inode is not counted to quota */
  129. #define S_DIRSYNC    64    /* Directory modifications are synchronous */
  130. #define S_NOCMTIME    128    /* Do not update file c/mtime */
  131. #define S_SWAPFILE    256    /* Do not truncate: swapon got its bmaps */
  132.  
  133. /*
  134.  * Note that nosuid etc flags are inode-specific: setting some file-system
  135.  * flags just means all the inodes inherit those flags by default. It might be
  136.  * possible to override it selectively if you really wanted to with some
  137.  * ioctl() that is not currently implemented.
  138.  *
  139.  * Exception: MS_RDONLY is always applied to the entire file system.
  140.  *
  141.  * Unfortunately, it is possible to change a filesystems flags with it mounted
  142.  * with files in use.  This means that all of the inodes will not have their
  143.  * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
  144.  * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
  145.  */
  146. #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
  147.  
  148. #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
  149. #define IS_SYNC(inode)        (__IS_FLG(inode, MS_SYNCHRONOUS) || \
  150.                     ((inode)->i_flags & S_SYNC))
  151. #define IS_DIRSYNC(inode)    (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
  152.                     ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
  153. #define IS_MANDLOCK(inode)    __IS_FLG(inode, MS_MANDLOCK)
  154.  
  155. #define IS_NOQUOTA(inode)    ((inode)->i_flags & S_NOQUOTA)
  156. #define IS_APPEND(inode)    ((inode)->i_flags & S_APPEND)
  157. #define IS_IMMUTABLE(inode)    ((inode)->i_flags & S_IMMUTABLE)
  158. #define IS_NOATIME(inode)    (__IS_FLG(inode, MS_NOATIME) || ((inode)->i_flags & S_NOATIME))
  159. #define IS_NODIRATIME(inode)    __IS_FLG(inode, MS_NODIRATIME)
  160. #define IS_POSIXACL(inode)    __IS_FLG(inode, MS_POSIXACL)
  161.  
  162. #define IS_DEADDIR(inode)    ((inode)->i_flags & S_DEAD)
  163. #define IS_NOCMTIME(inode)    ((inode)->i_flags & S_NOCMTIME)
  164. #define IS_SWAPFILE(inode)    ((inode)->i_flags & S_SWAPFILE)
  165.  
  166. /* the read-only stuff doesn't really belong here, but any other place is
  167.    probably as bad and I don't want to create yet another include file. */
  168.  
  169. #define BLKROSET   _IO(0x12,93)    /* set device read-only (0 = read-write) */
  170. #define BLKROGET   _IO(0x12,94)    /* get read-only status (0 = read_write) */
  171. #define BLKRRPART  _IO(0x12,95)    /* re-read partition table */
  172. #define BLKGETSIZE _IO(0x12,96)    /* return device size /512 (long *arg) */
  173. #define BLKFLSBUF  _IO(0x12,97)    /* flush buffer cache */
  174. #define BLKRASET   _IO(0x12,98)    /* set read ahead for block device */
  175. #define BLKRAGET   _IO(0x12,99)    /* get current read ahead setting */
  176. #define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
  177. #define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
  178. #define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
  179. #define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
  180. #define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
  181. #if 0
  182. #define BLKPG      _IO(0x12,105)/* See blkpg.h */
  183.  
  184. /* Some people are morons.  Do not use sizeof! */
  185.  
  186. #define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
  187. #define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
  188. /* This was here just to show that the number is taken -
  189.    probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
  190. #endif
  191. /* A jump here: 108-111 have been used for various private purposes. */
  192. #define BLKBSZGET  _IOR(0x12,112,size_t)
  193. #define BLKBSZSET  _IOW(0x12,113,size_t)
  194. #define BLKGETSIZE64 _IOR(0x12,114,size_t)    /* return device size in bytes (u64 *arg) */
  195.  
  196. #define BMAP_IOCTL 1        /* obsolete - kept for compatibility */
  197. #define FIBMAP       _IO(0x00,1)    /* bmap access */
  198. #define FIGETBSZ   _IO(0x00,2)    /* get the block size used for bmap */
  199.  
  200. #ifdef __KERNEL__
  201.  
  202. #include <linux/linkage.h>
  203. #include <linux/wait.h>
  204. #include <linux/types.h>
  205. #include <linux/kdev_t.h>
  206. #include <linux/dcache.h>
  207. #include <linux/stat.h>
  208. #include <linux/cache.h>
  209. #include <linux/kobject.h>
  210. #include <linux/list.h>
  211. #include <linux/radix-tree.h>
  212. #include <linux/prio_tree.h>
  213. #include <linux/audit.h>
  214. #include <linux/init.h>
  215.  
  216. #include <asm/atomic.h>
  217. #include <asm/semaphore.h>
  218. #include <asm/byteorder.h>
  219.  
  220. struct iovec;
  221. struct nameidata;
  222. struct pipe_inode_info;
  223. struct poll_table_struct;
  224. struct kstatfs;
  225. struct vm_area_struct;
  226. struct vfsmount;
  227.  
  228. /* Used to be a macro which just called the function, now just a function */
  229. extern void update_atime (struct inode *);
  230.  
  231. extern void __init inode_init(unsigned long);
  232. extern void __init inode_init_early(void);
  233. extern void __init mnt_init(unsigned long);
  234. extern void __init files_init(unsigned long);
  235.  
  236. struct buffer_head;
  237. typedef int (get_block_t)(struct inode *inode, sector_t iblock,
  238.             struct buffer_head *bh_result, int create);
  239. typedef int (get_blocks_t)(struct inode *inode, sector_t iblock,
  240.             unsigned long max_blocks,
  241.             struct buffer_head *bh_result, int create);
  242. typedef void (dio_iodone_t)(struct inode *inode, loff_t offset,
  243.             ssize_t bytes, void *private);
  244.  
  245. /*
  246.  * Attribute flags.  These should be or-ed together to figure out what
  247.  * has been changed!
  248.  */
  249. #define ATTR_MODE    1
  250. #define ATTR_UID    2
  251. #define ATTR_GID    4
  252. #define ATTR_SIZE    8
  253. #define ATTR_ATIME    16
  254. #define ATTR_MTIME    32
  255. #define ATTR_CTIME    64
  256. #define ATTR_ATIME_SET    128
  257. #define ATTR_MTIME_SET    256
  258. #define ATTR_FORCE    512    /* Not a change, but a change it */
  259. #define ATTR_ATTR_FLAG    1024
  260. #define ATTR_KILL_SUID    2048
  261. #define ATTR_KILL_SGID    4096
  262.  
  263. /*
  264.  * This is the Inode Attributes structure, used for notify_change().  It
  265.  * uses the above definitions as flags, to know which values have changed.
  266.  * Also, in this manner, a Filesystem can look at only the values it cares
  267.  * about.  Basically, these are the attributes that the VFS layer can
  268.  * request to change from the FS layer.
  269.  *
  270.  * Derek Atkins <warlord@MIT.EDU> 94-10-20
  271.  */
  272. struct iattr {
  273.     unsigned int    ia_valid;
  274.     umode_t        ia_mode;
  275.     uid_t        ia_uid;
  276.     gid_t        ia_gid;
  277.     loff_t        ia_size;
  278.     struct timespec    ia_atime;
  279.     struct timespec    ia_mtime;
  280.     struct timespec    ia_ctime;
  281.     unsigned int    ia_attr_flags;
  282. };
  283.  
  284. /*
  285.  * This is the inode attributes flag definitions
  286.  */
  287. #define ATTR_FLAG_SYNCRONOUS    1     /* Syncronous write */
  288. #define ATTR_FLAG_NOATIME    2     /* Don't update atime */
  289. #define ATTR_FLAG_APPEND    4     /* Append-only file */
  290. #define ATTR_FLAG_IMMUTABLE    8     /* Immutable file */
  291. #define ATTR_FLAG_NODIRATIME    16     /* Don't update atime for directory */
  292.  
  293. /*
  294.  * Includes for diskquotas.
  295.  */
  296. #include <linux/quota.h>
  297.  
  298. /*
  299.  * oh the beauties of C type declarations.
  300.  */
  301. struct page;
  302. struct address_space;
  303. struct writeback_control;
  304. struct kiocb;
  305.  
  306. struct address_space_operations {
  307.     int (*writepage)(struct page *page, struct writeback_control *wbc);
  308.     int (*readpage)(struct file *, struct page *);
  309.     int (*sync_page)(struct page *);
  310.  
  311.     /* Write back some dirty pages from this mapping. */
  312.     int (*writepages)(struct address_space *, struct writeback_control *);
  313.  
  314.     /* Set a page dirty */
  315.     int (*set_page_dirty)(struct page *page);
  316.  
  317.     int (*readpages)(struct file *filp, struct address_space *mapping,
  318.             struct list_head *pages, unsigned nr_pages);
  319.  
  320.     /*
  321.      * ext3 requires that a successful prepare_write() call be followed
  322.      * by a commit_write() call - they must be balanced
  323.      */
  324.     int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
  325.     int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
  326.     /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
  327.     sector_t (*bmap)(struct address_space *, sector_t);
  328.     int (*invalidatepage) (struct page *, unsigned long);
  329.     int (*releasepage) (struct page *, int);
  330.     ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
  331.             loff_t offset, unsigned long nr_segs);
  332. };
  333.  
  334. struct backing_dev_info;
  335. struct address_space {
  336.     struct inode        *host;        /* owner: inode, block_device */
  337.     struct radix_tree_root    page_tree;    /* radix tree of all pages */
  338.     spinlock_t        tree_lock;    /* and spinlock protecting it */
  339.     unsigned int        i_mmap_writable;/* count VM_SHARED mappings */
  340.     struct prio_tree_root    i_mmap;        /* tree of private and shared mappings */
  341.     struct list_head    i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
  342.     spinlock_t        i_mmap_lock;    /* protect tree, count, list */
  343.     unsigned int        truncate_count;    /* Cover race condition with truncate */
  344.     unsigned long        nrpages;    /* number of total pages */
  345.     pgoff_t            writeback_index;/* writeback starts here */
  346.     struct address_space_operations *a_ops;    /* methods */
  347.     unsigned long        flags;        /* error bits/gfp mask */
  348.     struct backing_dev_info *backing_dev_info; /* device readahead, etc */
  349.     spinlock_t        private_lock;    /* for use by the address_space */
  350.     struct list_head    private_list;    /* ditto */
  351.     struct address_space    *assoc_mapping;    /* ditto */
  352. } __attribute__((aligned(sizeof(long))));
  353.     /*
  354.      * On most architectures that alignment is already the case; but
  355.      * must be enforced here for CRIS, to let the least signficant bit
  356.      * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
  357.      */
  358.  
  359. struct block_device {
  360.     dev_t            bd_dev;  /* not a kdev_t - it's a search key */
  361.     struct inode *        bd_inode;    /* will die */
  362.     int            bd_openers;
  363.     struct semaphore    bd_sem;    /* open/close mutex */
  364.     struct semaphore    bd_mount_sem;    /* mount mutex */
  365.     struct list_head    bd_inodes;
  366.     void *            bd_holder;
  367.     int            bd_holders;
  368.     struct block_device *    bd_contains;
  369.     unsigned        bd_block_size;
  370.     struct hd_struct *    bd_part;
  371.     /* number of times partitions within this device have been opened. */
  372.     unsigned        bd_part_count;
  373.     int            bd_invalidated;
  374.     struct gendisk *    bd_disk;
  375.     struct list_head    bd_list;
  376.     struct backing_dev_info *bd_inode_backing_dev_info;
  377.     /*
  378.      * Private data.  You must have bd_claim'ed the block_device
  379.      * to use this.  NOTE:  bd_claim allows an owner to claim
  380.      * the same device multiple times, the owner must take special
  381.      * care to not mess up bd_private for that case.
  382.      */
  383.     unsigned long        bd_private;
  384. };
  385.  
  386. /*
  387.  * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
  388.  * radix trees
  389.  */
  390. #define PAGECACHE_TAG_DIRTY    0
  391. #define PAGECACHE_TAG_WRITEBACK    1
  392.  
  393. int mapping_tagged(struct address_space *mapping, int tag);
  394.  
  395. /*
  396.  * Might pages of this file be mapped into userspace?
  397.  */
  398. static inline int mapping_mapped(struct address_space *mapping)
  399. {
  400.     return    !prio_tree_empty(&mapping->i_mmap) ||
  401.         !list_empty(&mapping->i_mmap_nonlinear);
  402. }
  403.  
  404. /*
  405.  * Might pages of this file have been modified in userspace?
  406.  * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
  407.  * marks vma as VM_SHARED if it is shared, and the file was opened for
  408.  * writing i.e. vma may be mprotected writable even if now readonly.
  409.  */
  410. static inline int mapping_writably_mapped(struct address_space *mapping)
  411. {
  412.     return mapping->i_mmap_writable != 0;
  413. }
  414.  
  415. /*
  416.  * Use sequence counter to get consistent i_size on 32-bit processors.
  417.  */
  418. #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
  419. #include <linux/seqlock.h>
  420. #define __NEED_I_SIZE_ORDERED
  421. #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
  422. #else
  423. #define i_size_ordered_init(inode) do { } while (0)
  424. #endif
  425.  
  426. struct inode {
  427.     struct hlist_node    i_hash;
  428.     struct list_head    i_list;
  429.     struct list_head    i_sb_list;
  430.     struct list_head    i_dentry;
  431.     unsigned long        i_ino;
  432.     atomic_t        i_count;
  433.     umode_t            i_mode;
  434.     unsigned int        i_nlink;
  435.     uid_t            i_uid;
  436.     gid_t            i_gid;
  437.     dev_t            i_rdev;
  438.     loff_t            i_size;
  439.     struct timespec        i_atime;
  440.     struct timespec        i_mtime;
  441.     struct timespec        i_ctime;
  442.     unsigned int        i_blkbits;
  443.     unsigned long        i_blksize;
  444.     unsigned long        i_version;
  445.     unsigned long        i_blocks;
  446.     unsigned short          i_bytes;
  447.     unsigned char        i_sock;
  448.     spinlock_t        i_lock;    /* i_blocks, i_bytes, maybe i_size */
  449.     struct semaphore    i_sem;
  450.     struct rw_semaphore    i_alloc_sem;
  451.     struct inode_operations    *i_op;
  452.     struct file_operations    *i_fop;    /* former ->i_op->default_file_ops */
  453.     struct super_block    *i_sb;
  454.     struct file_lock    *i_flock;
  455.     struct address_space    *i_mapping;
  456.     struct address_space    i_data;
  457. #ifdef CONFIG_QUOTA
  458.     struct dquot        *i_dquot[MAXQUOTAS];
  459. #endif
  460.     /* These three should probably be a union */
  461.     struct list_head    i_devices;
  462.     struct pipe_inode_info    *i_pipe;
  463.     struct block_device    *i_bdev;
  464.     struct cdev        *i_cdev;
  465.     int            i_cindex;
  466.  
  467.     __u32            i_generation;
  468.  
  469. #ifdef CONFIG_DNOTIFY
  470.     unsigned long        i_dnotify_mask; /* Directory notify events */
  471.     struct dnotify_struct    *i_dnotify; /* for directory notifications */
  472. #endif
  473.  
  474.     unsigned long        i_state;
  475.     unsigned long        dirtied_when;    /* jiffies of first dirtying */
  476.  
  477.     unsigned int        i_flags;
  478.  
  479.     atomic_t        i_writecount;
  480.     void            *i_security;
  481.     union {
  482.         void        *generic_ip;
  483.     } u;
  484. #ifdef __NEED_I_SIZE_ORDERED
  485.     seqcount_t        i_size_seqcount;
  486. #endif
  487. };
  488.  
  489. /*
  490.  * NOTE: in a 32bit arch with a preemptable kernel and
  491.  * an UP compile the i_size_read/write must be atomic
  492.  * with respect to the local cpu (unlike with preempt disabled),
  493.  * but they don't need to be atomic with respect to other cpus like in
  494.  * true SMP (so they need either to either locally disable irq around
  495.  * the read or for example on x86 they can be still implemented as a
  496.  * cmpxchg8b without the need of the lock prefix). For SMP compiles
  497.  * and 64bit archs it makes no difference if preempt is enabled or not.
  498.  */
  499. static inline loff_t i_size_read(struct inode *inode)
  500. {
  501. #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
  502.     loff_t i_size;
  503.     unsigned int seq;
  504.  
  505.     do {
  506.         seq = read_seqcount_begin(&inode->i_size_seqcount);
  507.         i_size = inode->i_size;
  508.     } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
  509.     return i_size;
  510. #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
  511.     loff_t i_size;
  512.  
  513.     preempt_disable();
  514.     i_size = inode->i_size;
  515.     preempt_enable();
  516.     return i_size;
  517. #else
  518.     return inode->i_size;
  519. #endif
  520. }
  521.  
  522.  
  523. static inline void i_size_write(struct inode *inode, loff_t i_size)
  524. {
  525. #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
  526.     write_seqcount_begin(&inode->i_size_seqcount);
  527.     inode->i_size = i_size;
  528.     write_seqcount_end(&inode->i_size_seqcount);
  529. #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
  530.     preempt_disable();
  531.     inode->i_size = i_size;
  532.     preempt_enable();
  533. #else
  534.     inode->i_size = i_size;
  535. #endif
  536. }
  537.  
  538. static inline unsigned iminor(struct inode *inode)
  539. {
  540.     return MINOR(inode->i_rdev);
  541. }
  542.  
  543. static inline unsigned imajor(struct inode *inode)
  544. {
  545.     return MAJOR(inode->i_rdev);
  546. }
  547.  
  548. extern struct block_device *I_BDEV(struct inode *inode);
  549.  
  550. struct fown_struct {
  551.     rwlock_t lock;          /* protects pid, uid, euid fields */
  552.     int pid;        /* pid or -pgrp where SIGIO should be sent */
  553.     uid_t uid, euid;    /* uid/euid of process setting the owner */
  554.     void *security;
  555.     int signum;        /* posix.1b rt signal to be delivered on IO */
  556. };
  557.  
  558. /*
  559.  * Track a single file's readahead state
  560.  */
  561. struct file_ra_state {
  562.     unsigned long start;        /* Current window */
  563.     unsigned long size;
  564.     unsigned long flags;        /* ra flags RA_FLAG_xxx*/
  565.     unsigned long cache_hit;    /* cache hit count*/
  566.     unsigned long prev_page;    /* Cache last read() position */
  567.     unsigned long ahead_start;    /* Ahead window */
  568.     unsigned long ahead_size;
  569.     unsigned long ra_pages;        /* Maximum readahead window */
  570.     unsigned long mmap_hit;        /* Cache hit stat for mmap accesses */
  571.     unsigned long mmap_miss;    /* Cache miss stat for mmap accesses */
  572. };
  573. #define RA_FLAG_MISS 0x01    /* a cache miss occured against this file */
  574. #define RA_FLAG_INCACHE 0x02    /* file is already in cache */
  575.  
  576. struct file {
  577.     struct list_head    f_list;
  578.     struct dentry        *f_dentry;
  579.     struct vfsmount         *f_vfsmnt;
  580.     struct file_operations    *f_op;
  581.     atomic_t        f_count;
  582.     unsigned int         f_flags;
  583.     mode_t            f_mode;
  584.     int            f_error;
  585.     loff_t            f_pos;
  586.     struct fown_struct    f_owner;
  587.     unsigned int        f_uid, f_gid;
  588.     struct file_ra_state    f_ra;
  589.  
  590.     size_t            f_maxcount;
  591.     unsigned long        f_version;
  592.     void            *f_security;
  593.  
  594.     /* needed for tty driver, and maybe others */
  595.     void            *private_data;
  596.  
  597. #ifdef CONFIG_EPOLL
  598.     /* Used by fs/eventpoll.c to link all the hooks to this file */
  599.     struct list_head    f_ep_links;
  600.     spinlock_t        f_ep_lock;
  601. #endif /* #ifdef CONFIG_EPOLL */
  602.     struct address_space    *f_mapping;
  603. };
  604. extern spinlock_t files_lock;
  605. #define file_list_lock() spin_lock(&files_lock);
  606. #define file_list_unlock() spin_unlock(&files_lock);
  607.  
  608. #define get_file(x)    atomic_inc(&(x)->f_count)
  609. #define file_count(x)    atomic_read(&(x)->f_count)
  610.  
  611. #define    MAX_NON_LFS    ((1UL<<31) - 1)
  612.  
  613. /* Page cache limit. The filesystems should put that into their s_maxbytes 
  614.    limits, otherwise bad things can happen in VM. */ 
  615. #if BITS_PER_LONG==32
  616. #define MAX_LFS_FILESIZE    (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1) 
  617. #elif BITS_PER_LONG==64
  618. #define MAX_LFS_FILESIZE     0x7fffffffffffffffUL
  619. #endif
  620.  
  621. #define FL_POSIX    1
  622. #define FL_FLOCK    2
  623. #define FL_ACCESS    8    /* not trying to lock, just looking */
  624. #define FL_LOCKD    16    /* lock held by rpc.lockd */
  625. #define FL_LEASE    32    /* lease held on this file */
  626. #define FL_SLEEP    128    /* A blocking lock */
  627.  
  628. /*
  629.  * The POSIX file lock owner is determined by
  630.  * the "struct files_struct" in the thread group
  631.  * (or NULL for no owner - BSD locks).
  632.  *
  633.  * Lockd stuffs a "host" pointer into this.
  634.  */
  635. typedef struct files_struct *fl_owner_t;
  636.  
  637. struct file_lock_operations {
  638.     void (*fl_insert)(struct file_lock *);    /* lock insertion callback */
  639.     void (*fl_remove)(struct file_lock *);    /* lock removal callback */
  640.     void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
  641.     void (*fl_release_private)(struct file_lock *);
  642. };
  643.  
  644. struct lock_manager_operations {
  645.     int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
  646.     void (*fl_notify)(struct file_lock *);    /* unblock callback */
  647.     void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
  648.     void (*fl_release_private)(struct file_lock *);
  649.     void (*fl_break)(struct file_lock *);
  650. };
  651.  
  652. /* that will die - we need it for nfs_lock_info */
  653. #include <linux/nfs_fs_i.h>
  654.  
  655. struct file_lock {
  656.     struct file_lock *fl_next;    /* singly linked list for this inode  */
  657.     struct list_head fl_link;    /* doubly linked list of all locks */
  658.     struct list_head fl_block;    /* circular list of blocked processes */
  659.     fl_owner_t fl_owner;
  660.     unsigned int fl_pid;
  661.     wait_queue_head_t fl_wait;
  662.     struct file *fl_file;
  663.     unsigned char fl_flags;
  664.     unsigned char fl_type;
  665.     loff_t fl_start;
  666.     loff_t fl_end;
  667.  
  668.     struct fasync_struct *    fl_fasync; /* for lease break notifications */
  669.     unsigned long fl_break_time;    /* for nonblocking lease breaks */
  670.  
  671.     struct file_lock_operations *fl_ops;    /* Callbacks for filesystems */
  672.     struct lock_manager_operations *fl_lmops;    /* Callbacks for lockmanagers */
  673.     union {
  674.         struct nfs_lock_info    nfs_fl;
  675.     } fl_u;
  676. };
  677.  
  678. /* The following constant reflects the upper bound of the file/locking space */
  679. #ifndef OFFSET_MAX
  680. #define INT_LIMIT(x)    (~((x)1 << (sizeof(x)*8 - 1)))
  681. #define OFFSET_MAX    INT_LIMIT(loff_t)
  682. #define OFFT_OFFSET_MAX    INT_LIMIT(off_t)
  683. #endif
  684.  
  685. extern struct list_head file_lock_list;
  686.  
  687. #include <linux/fcntl.h>
  688.  
  689. extern int fcntl_getlk(struct file *, struct flock __user *);
  690. extern int fcntl_setlk(struct file *, unsigned int, struct flock __user *);
  691.  
  692. #if BITS_PER_LONG == 32
  693. extern int fcntl_getlk64(struct file *, struct flock64 __user *);
  694. extern int fcntl_setlk64(struct file *, unsigned int, struct flock64 __user *);
  695. #endif
  696.  
  697. extern void send_sigio(struct fown_struct *fown, int fd, int band);
  698. extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
  699. extern int fcntl_getlease(struct file *filp);
  700.  
  701. /* fs/locks.c */
  702. extern void locks_init_lock(struct file_lock *);
  703. extern void locks_copy_lock(struct file_lock *, struct file_lock *);
  704. extern void locks_remove_posix(struct file *, fl_owner_t);
  705. extern void locks_remove_flock(struct file *);
  706. extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);
  707. extern int posix_lock_file(struct file *, struct file_lock *);
  708. extern int posix_lock_file_wait(struct file *, struct file_lock *);
  709. extern void posix_block_lock(struct file_lock *, struct file_lock *);
  710. extern void posix_unblock_lock(struct file *, struct file_lock *);
  711. extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);
  712. extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
  713. extern int __break_lease(struct inode *inode, unsigned int flags);
  714. extern void lease_get_mtime(struct inode *, struct timespec *time);
  715. extern int setlease(struct file *, long, struct file_lock **);
  716. extern void remove_lease(struct file_lock *);
  717. extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
  718. extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
  719. extern void steal_locks(fl_owner_t from);
  720.  
  721. struct fasync_struct {
  722.     int    magic;
  723.     int    fa_fd;
  724.     struct    fasync_struct    *fa_next; /* singly linked list */
  725.     struct    file         *fa_file;
  726. };
  727.  
  728. #define FASYNC_MAGIC 0x4601
  729.  
  730. /* SMP safe fasync helpers: */
  731. extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
  732. /* can be called from interrupts */
  733. extern void kill_fasync(struct fasync_struct **, int, int);
  734. /* only for net: no internal synchronization */
  735. extern void __kill_fasync(struct fasync_struct *, int, int);
  736.  
  737. extern int f_setown(struct file *filp, unsigned long arg, int force);
  738. extern void f_delown(struct file *filp);
  739. extern int send_sigurg(struct fown_struct *fown);
  740.  
  741. /*
  742.  *    Umount options
  743.  */
  744.  
  745. #define MNT_FORCE    0x00000001    /* Attempt to forcibily umount */
  746. #define MNT_DETACH    0x00000002    /* Just detach from the tree */
  747. #define MNT_EXPIRE    0x00000004    /* Mark for expiry */
  748.  
  749. extern struct list_head super_blocks;
  750. extern spinlock_t sb_lock;
  751.  
  752. #define sb_entry(list)    list_entry((list), struct super_block, s_list)
  753. #define S_BIAS (1<<30)
  754. struct super_block {
  755.     struct list_head    s_list;        /* Keep this first */
  756.     dev_t            s_dev;        /* search index; _not_ kdev_t */
  757.     unsigned long        s_blocksize;
  758.     unsigned long        s_old_blocksize;
  759.     unsigned char        s_blocksize_bits;
  760.     unsigned char        s_dirt;
  761.     unsigned long long    s_maxbytes;    /* Max file size */
  762.     struct file_system_type    *s_type;
  763.     struct super_operations    *s_op;
  764.     struct dquot_operations    *dq_op;
  765.      struct quotactl_ops    *s_qcop;
  766.     struct export_operations *s_export_op;
  767.     unsigned long        s_flags;
  768.     unsigned long        s_magic;
  769.     struct dentry        *s_root;
  770.     struct rw_semaphore    s_umount;
  771.     struct semaphore    s_lock;
  772.     int            s_count;
  773.     int            s_syncing;
  774.     int            s_need_sync_fs;
  775.     atomic_t        s_active;
  776.     void                    *s_security;
  777.     struct xattr_handler    **s_xattr;
  778.  
  779.     struct list_head    s_inodes;    /* all inodes */
  780.     struct list_head    s_dirty;    /* dirty inodes */
  781.     struct list_head    s_io;        /* parked for writeback */
  782.     struct hlist_head    s_anon;        /* anonymous dentries for (nfs) exporting */
  783.     struct list_head    s_files;
  784.  
  785.     struct block_device    *s_bdev;
  786.     struct list_head    s_instances;
  787.     struct quota_info    s_dquot;    /* Diskquota specific options */
  788.  
  789.     int            s_frozen;
  790.     wait_queue_head_t    s_wait_unfrozen;
  791.  
  792.     char s_id[32];                /* Informational name */
  793.  
  794.     void             *s_fs_info;    /* Filesystem private info */
  795.  
  796.     /*
  797.      * The next field is for VFS *only*. No filesystems have any business
  798.      * even looking at it. You had been warned.
  799.      */
  800.     struct semaphore s_vfs_rename_sem;    /* Kludge */
  801.  
  802.     /* Granuality of c/m/atime in ns.
  803.        Cannot be worse than a second */
  804.     u32           s_time_gran;
  805. };
  806.  
  807. extern struct timespec current_fs_time(struct super_block *sb);
  808.  
  809. /*
  810.  * Snapshotting support.
  811.  */
  812. enum {
  813.     SB_UNFROZEN = 0,
  814.     SB_FREEZE_WRITE    = 1,
  815.     SB_FREEZE_TRANS = 2,
  816. };
  817.  
  818. #define vfs_check_frozen(sb, level) \
  819.     wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
  820.  
  821. /*
  822.  * Superblock locking.
  823.  */
  824. static inline void lock_super(struct super_block * sb)
  825. {
  826.     down(&sb->s_lock);
  827. }
  828.  
  829. static inline void unlock_super(struct super_block * sb)
  830. {
  831.     up(&sb->s_lock);
  832. }
  833.  
  834. /*
  835.  * VFS helper functions..
  836.  */
  837. extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
  838. extern int vfs_mkdir(struct inode *, struct dentry *, int);
  839. extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
  840. extern int vfs_symlink(struct inode *, struct dentry *, const char *, int);
  841. extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
  842. extern int vfs_rmdir(struct inode *, struct dentry *);
  843. extern int vfs_unlink(struct inode *, struct dentry *);
  844. extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
  845.  
  846. /*
  847.  * VFS dentry helper functions.
  848.  */
  849. extern void dentry_unhash(struct dentry *dentry);
  850.  
  851. /*
  852.  * File types
  853.  *
  854.  * NOTE! These match bits 12..15 of stat.st_mode
  855.  * (ie "(i_mode >> 12) & 15").
  856.  */
  857. #define DT_UNKNOWN    0
  858. #define DT_FIFO        1
  859. #define DT_CHR        2
  860. #define DT_DIR        4
  861. #define DT_BLK        6
  862. #define DT_REG        8
  863. #define DT_LNK        10
  864. #define DT_SOCK        12
  865. #define DT_WHT        14
  866.  
  867. #define OSYNC_METADATA    (1<<0)
  868. #define OSYNC_DATA    (1<<1)
  869. #define OSYNC_INODE    (1<<2)
  870. int generic_osync_inode(struct inode *, struct address_space *, int);
  871.  
  872. /*
  873.  * This is the "filldir" function type, used by readdir() to let
  874.  * the kernel specify what kind of dirent layout it wants to have.
  875.  * This allows the kernel to read directories into kernel space or
  876.  * to have different dirent layouts depending on the binary type.
  877.  */
  878. typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);
  879.  
  880. struct block_device_operations {
  881.     int (*open) (struct inode *, struct file *);
  882.     int (*release) (struct inode *, struct file *);
  883.     int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
  884.     long (*compat_ioctl) (struct file *, unsigned, unsigned long);
  885.     int (*media_changed) (struct gendisk *);
  886.     int (*revalidate_disk) (struct gendisk *);
  887.     struct module *owner;
  888. };
  889.  
  890. /*
  891.  * "descriptor" for what we're up to with a read for sendfile().
  892.  * This allows us to use the same read code yet
  893.  * have multiple different users of the data that
  894.  * we read from a file.
  895.  *
  896.  * The simplest case just copies the data to user
  897.  * mode.
  898.  */
  899. typedef struct {
  900.     size_t written;
  901.     size_t count;
  902.     union {
  903.         char __user * buf;
  904.         void *data;
  905.     } arg;
  906.     int error;
  907. } read_descriptor_t;
  908.  
  909. typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
  910.  
  911. /* These macros are for out of kernel modules to test that
  912.  * the kernel supports the unlocked_ioctl and compat_ioctl
  913.  * fields in struct file_operations. */
  914. #define HAVE_COMPAT_IOCTL 1
  915. #define HAVE_UNLOCKED_IOCTL 1
  916.  
  917. /*
  918.  * NOTE:
  919.  * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl
  920.  * can be called without the big kernel lock held in all filesystems.
  921.  */
  922. struct file_operations {
  923.     struct module *owner;
  924.     loff_t (*llseek) (struct file *, loff_t, int);
  925.     ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
  926.     ssize_t (*aio_read) (struct kiocb *, char __user *, size_t, loff_t);
  927.     ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
  928.     ssize_t (*aio_write) (struct kiocb *, const char __user *, size_t, loff_t);
  929.     int (*readdir) (struct file *, void *, filldir_t);
  930.     unsigned int (*poll) (struct file *, struct poll_table_struct *);
  931.     int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
  932.     long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
  933.     long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
  934.     int (*mmap) (struct file *, struct vm_area_struct *);
  935.     int (*open) (struct inode *, struct file *);
  936.     int (*flush) (struct file *);
  937.     int (*release) (struct inode *, struct file *);
  938.     int (*fsync) (struct file *, struct dentry *, int datasync);
  939.     int (*aio_fsync) (struct kiocb *, int datasync);
  940.     int (*fasync) (int, struct file *, int);
  941.     int (*lock) (struct file *, int, struct file_lock *);
  942.     ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
  943.     ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
  944.     ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
  945.     ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
  946.     unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
  947.     int (*check_flags)(int);
  948.     int (*dir_notify)(struct file *filp, unsigned long arg);
  949.     int (*flock) (struct file *, int, struct file_lock *);
  950. };
  951.  
  952. struct inode_operations {
  953.     int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
  954.     struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
  955.     int (*link) (struct dentry *,struct inode *,struct dentry *);
  956.     int (*unlink) (struct inode *,struct dentry *);
  957.     int (*symlink) (struct inode *,struct dentry *,const char *);
  958.     int (*mkdir) (struct inode *,struct dentry *,int);
  959.     int (*rmdir) (struct inode *,struct dentry *);
  960.     int (*mknod) (struct inode *,struct dentry *,int,dev_t);
  961.     int (*rename) (struct inode *, struct dentry *,
  962.             struct inode *, struct dentry *);
  963.     int (*readlink) (struct dentry *, char __user *,int);
  964.     int (*follow_link) (struct dentry *, struct nameidata *);
  965.     void (*put_link) (struct dentry *, struct nameidata *);
  966.     void (*truncate) (struct inode *);
  967.     int (*permission) (struct inode *, int, struct nameidata *);
  968.     int (*setattr) (struct dentry *, struct iattr *);
  969.     int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
  970.     int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
  971.     ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
  972.     ssize_t (*listxattr) (struct dentry *, char *, size_t);
  973.     int (*removexattr) (struct dentry *, const char *);
  974. };
  975.  
  976. struct seq_file;
  977.  
  978. extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
  979. extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
  980. extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
  981.         unsigned long, loff_t *);
  982. extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
  983.         unsigned long, loff_t *);
  984.  
  985. /*
  986.  * NOTE: write_inode, delete_inode, clear_inode, put_inode can be called
  987.  * without the big kernel lock held in all filesystems.
  988.  */
  989. struct super_operations {
  990.        struct inode *(*alloc_inode)(struct super_block *sb);
  991.     void (*destroy_inode)(struct inode *);
  992.  
  993.     void (*read_inode) (struct inode *);
  994.   
  995.        void (*dirty_inode) (struct inode *);
  996.     int (*write_inode) (struct inode *, int);
  997.     void (*put_inode) (struct inode *);
  998.     void (*drop_inode) (struct inode *);
  999.     void (*delete_inode) (struct inode *);
  1000.     void (*put_super) (struct super_block *);
  1001.     void (*write_super) (struct super_block *);
  1002.     int (*sync_fs)(struct super_block *sb, int wait);
  1003.     void (*write_super_lockfs) (struct super_block *);
  1004.     void (*unlockfs) (struct super_block *);
  1005.     int (*statfs) (struct super_block *, struct kstatfs *);
  1006.     int (*remount_fs) (struct super_block *, int *, char *);
  1007.     void (*clear_inode) (struct inode *);
  1008.     void (*umount_begin) (struct super_block *);
  1009.  
  1010.     int (*show_options)(struct seq_file *, struct vfsmount *);
  1011.  
  1012.     ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
  1013.     ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
  1014. };
  1015.  
  1016. /* Inode state bits.  Protected by inode_lock. */
  1017. #define I_DIRTY_SYNC        1 /* Not dirty enough for O_DATASYNC */
  1018. #define I_DIRTY_DATASYNC    2 /* Data-related inode changes pending */
  1019. #define I_DIRTY_PAGES        4 /* Data-related inode changes pending */
  1020. #define __I_LOCK        3
  1021. #define I_LOCK            (1 << __I_LOCK)
  1022. #define I_FREEING        16
  1023. #define I_CLEAR            32
  1024. #define I_NEW            64
  1025.  
  1026. #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
  1027.  
  1028. extern void __mark_inode_dirty(struct inode *, int);
  1029. static inline void mark_inode_dirty(struct inode *inode)
  1030. {
  1031.     __mark_inode_dirty(inode, I_DIRTY);
  1032. }
  1033.  
  1034. static inline void mark_inode_dirty_sync(struct inode *inode)
  1035. {
  1036.     __mark_inode_dirty(inode, I_DIRTY_SYNC);
  1037. }
  1038.  
  1039. static inline void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
  1040. {
  1041.     /* per-mountpoint checks will go here */
  1042.     update_atime(dentry->d_inode);
  1043. }
  1044.  
  1045. static inline void file_accessed(struct file *file)
  1046. {
  1047.     if (!(file->f_flags & O_NOATIME))
  1048.         touch_atime(file->f_vfsmnt, file->f_dentry);
  1049. }
  1050.  
  1051. int sync_inode(struct inode *inode, struct writeback_control *wbc);
  1052.  
  1053. /**
  1054.  * &export_operations - for nfsd to communicate with file systems
  1055.  * decode_fh:      decode a file handle fragment and return a &struct dentry
  1056.  * encode_fh:      encode a file handle fragment from a dentry
  1057.  * get_name:       find the name for a given inode in a given directory
  1058.  * get_parent:     find the parent of a given directory
  1059.  * get_dentry:     find a dentry for the inode given a file handle sub-fragment
  1060.  *
  1061.  * Description:
  1062.  *    The export_operations structure provides a means for nfsd to communicate
  1063.  *    with a particular exported file system  - particularly enabling nfsd and
  1064.  *    the filesystem to co-operate when dealing with file handles.
  1065.  *
  1066.  *    export_operations contains two basic operation for dealing with file handles,
  1067.  *    decode_fh() and encode_fh(), and allows for some other operations to be defined
  1068.  *    which standard helper routines use to get specific information from the
  1069.  *    filesystem.
  1070.  *
  1071.  *    nfsd encodes information use to determine which filesystem a filehandle
  1072.  *    applies to in the initial part of the file handle.  The remainder, termed a
  1073.  *    file handle fragment, is controlled completely by the filesystem.
  1074.  *    The standard helper routines assume that this fragment will contain one or two
  1075.  *    sub-fragments, one which identifies the file, and one which may be used to
  1076.  *    identify the (a) directory containing the file.
  1077.  *
  1078.  *    In some situations, nfsd needs to get a dentry which is connected into a
  1079.  *    specific part of the file tree.  To allow for this, it passes the function
  1080.  *    acceptable() together with a @context which can be used to see if the dentry
  1081.  *    is acceptable.  As there can be multiple dentrys for a given file, the filesystem
  1082.  *    should check each one for acceptability before looking for the next.  As soon
  1083.  *    as an acceptable one is found, it should be returned.
  1084.  *
  1085.  * decode_fh:
  1086.  *    @decode_fh is given a &struct super_block (@sb), a file handle fragment (@fh, @fh_len)
  1087.  *    and an acceptability testing function (@acceptable, @context).  It should return
  1088.  *    a &struct dentry which refers to the same file that the file handle fragment refers
  1089.  *    to,  and which passes the acceptability test.  If it cannot, it should return
  1090.  *    a %NULL pointer if the file was found but no acceptable &dentries were available, or
  1091.  *    a %ERR_PTR error code indicating why it couldn't be found (e.g. %ENOENT or %ENOMEM).
  1092.  *
  1093.  * encode_fh:
  1094.  *    @encode_fh should store in the file handle fragment @fh (using at most @max_len bytes)
  1095.  *    information that can be used by @decode_fh to recover the file refered to by the
  1096.  *    &struct dentry @de.  If the @connectable flag is set, the encode_fh() should store
  1097.  *    sufficient information so that a good attempt can be made to find not only
  1098.  *    the file but also it's place in the filesystem.   This typically means storing
  1099.  *    a reference to de->d_parent in the filehandle fragment.
  1100.  *    encode_fh() should return the number of bytes stored or a negative error code
  1101.  *    such as %-ENOSPC
  1102.  *
  1103.  * get_name:
  1104.  *    @get_name should find a name for the given @child in the given @parent directory.
  1105.  *    The name should be stored in the @name (with the understanding that it is already
  1106.  *    pointing to a a %NAME_MAX+1 sized buffer.   get_name() should return %0 on success,
  1107.  *    a negative error code or error.
  1108.  *    @get_name will be called without @parent->i_sem held.
  1109.  *
  1110.  * get_parent:
  1111.  *    @get_parent should find the parent directory for the given @child which is also
  1112.  *    a directory.  In the event that it cannot be found, or storage space cannot be
  1113.  *    allocated, a %ERR_PTR should be returned.
  1114.  *
  1115.  * get_dentry:
  1116.  *    Given a &super_block (@sb) and a pointer to a file-system specific inode identifier,
  1117.  *    possibly an inode number, (@inump) get_dentry() should find the identified inode and
  1118.  *    return a dentry for that inode.
  1119.  *    Any suitable dentry can be returned including, if necessary, a new dentry created
  1120.  *    with d_alloc_root.  The caller can then find any other extant dentrys by following the
  1121.  *    d_alias links.  If a new dentry was created using d_alloc_root, DCACHE_NFSD_DISCONNECTED
  1122.  *    should be set, and the dentry should be d_rehash()ed.
  1123.  *
  1124.  *    If the inode cannot be found, either a %NULL pointer or an %ERR_PTR code can be returned.
  1125.  *    The @inump will be whatever was passed to nfsd_find_fh_dentry() in either the
  1126.  *    @obj or @parent parameters.
  1127.  *
  1128.  * Locking rules:
  1129.  *  get_parent is called with child->d_inode->i_sem down
  1130.  *  get_name is not (which is possibly inconsistent)
  1131.  */
  1132.  
  1133. struct export_operations {
  1134.     struct dentry *(*decode_fh)(struct super_block *sb, __u32 *fh, int fh_len, int fh_type,
  1135.              int (*acceptable)(void *context, struct dentry *de),
  1136.              void *context);
  1137.     int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
  1138.              int connectable);
  1139.  
  1140.     /* the following are only called from the filesystem itself */
  1141.     int (*get_name)(struct dentry *parent, char *name,
  1142.             struct dentry *child);
  1143.     struct dentry * (*get_parent)(struct dentry *child);
  1144.     struct dentry * (*get_dentry)(struct super_block *sb, void *inump);
  1145.  
  1146.     /* This is set by the exporting module to a standard helper */
  1147.     struct dentry * (*find_exported_dentry)(
  1148.         struct super_block *sb, void *obj, void *parent,
  1149.         int (*acceptable)(void *context, struct dentry *de),
  1150.         void *context);
  1151.  
  1152.  
  1153. };
  1154.  
  1155. extern struct dentry *
  1156. find_exported_dentry(struct super_block *sb, void *obj, void *parent,
  1157.              int (*acceptable)(void *context, struct dentry *de),
  1158.              void *context);
  1159.  
  1160. struct file_system_type {
  1161.     const char *name;
  1162.     int fs_flags;
  1163.     struct super_block *(*get_sb) (struct file_system_type *, int,
  1164.                        const char *, void *);
  1165.     void (*kill_sb) (struct super_block *);
  1166.     struct module *owner;
  1167.     struct file_system_type * next;
  1168.     struct list_head fs_supers;
  1169. };
  1170.  
  1171. struct super_block *get_sb_bdev(struct file_system_type *fs_type,
  1172.     int flags, const char *dev_name, void *data,
  1173.     int (*fill_super)(struct super_block *, void *, int));
  1174. struct super_block *get_sb_single(struct file_system_type *fs_type,
  1175.     int flags, void *data,
  1176.     int (*fill_super)(struct super_block *, void *, int));
  1177. struct super_block *get_sb_nodev(struct file_system_type *fs_type,
  1178.     int flags, void *data,
  1179.     int (*fill_super)(struct super_block *, void *, int));
  1180. void generic_shutdown_super(struct super_block *sb);
  1181. void kill_block_super(struct super_block *sb);
  1182. void kill_anon_super(struct super_block *sb);
  1183. void kill_litter_super(struct super_block *sb);
  1184. void deactivate_super(struct super_block *sb);
  1185. int set_anon_super(struct super_block *s, void *data);
  1186. struct super_block *sget(struct file_system_type *type,
  1187.             int (*test)(struct super_block *,void *),
  1188.             int (*set)(struct super_block *,void *),
  1189.             void *data);
  1190. struct super_block *get_sb_pseudo(struct file_system_type *, char *,
  1191.             struct super_operations *ops, unsigned long);
  1192. int __put_super(struct super_block *sb);
  1193. int __put_super_and_need_restart(struct super_block *sb);
  1194. void unnamed_dev_init(void);
  1195.  
  1196. /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
  1197. #define fops_get(fops) \
  1198.     (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
  1199. #define fops_put(fops) \
  1200.     do { if (fops) module_put((fops)->owner); } while(0)
  1201.  
  1202. extern int register_filesystem(struct file_system_type *);
  1203. extern int unregister_filesystem(struct file_system_type *);
  1204. extern struct vfsmount *kern_mount(struct file_system_type *);
  1205. extern int may_umount_tree(struct vfsmount *);
  1206. extern int may_umount(struct vfsmount *);
  1207. extern long do_mount(char *, char *, char *, unsigned long, void *);
  1208.  
  1209. extern int vfs_statfs(struct super_block *, struct kstatfs *);
  1210.  
  1211. #define FLOCK_VERIFY_READ  1
  1212. #define FLOCK_VERIFY_WRITE 2
  1213.  
  1214. extern int locks_mandatory_locked(struct inode *);
  1215. extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
  1216.  
  1217. /*
  1218.  * Candidates for mandatory locking have the setgid bit set
  1219.  * but no group execute bit -  an otherwise meaningless combination.
  1220.  */
  1221. #define MANDATORY_LOCK(inode) \
  1222.     (IS_MANDLOCK(inode) && ((inode)->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
  1223.  
  1224. static inline int locks_verify_locked(struct inode *inode)
  1225. {
  1226.     if (MANDATORY_LOCK(inode))
  1227.         return locks_mandatory_locked(inode);
  1228.     return 0;
  1229. }
  1230.  
  1231. extern int rw_verify_area(int, struct file *, loff_t *, size_t);
  1232.  
  1233. static inline int locks_verify_truncate(struct inode *inode,
  1234.                     struct file *filp,
  1235.                     loff_t size)
  1236. {
  1237.     if (inode->i_flock && MANDATORY_LOCK(inode))
  1238.         return locks_mandatory_area(
  1239.             FLOCK_VERIFY_WRITE, inode, filp,
  1240.             size < inode->i_size ? size : inode->i_size,
  1241.             (size < inode->i_size ? inode->i_size - size
  1242.              : size - inode->i_size)
  1243.         );
  1244.     return 0;
  1245. }
  1246.  
  1247. static inline int break_lease(struct inode *inode, unsigned int mode)
  1248. {
  1249.     if (inode->i_flock)
  1250.         return __break_lease(inode, mode);
  1251.     return 0;
  1252. }
  1253.  
  1254. /* fs/open.c */
  1255.  
  1256. extern int do_truncate(struct dentry *, loff_t start);
  1257. extern struct file *filp_open(const char *, int, int);
  1258. extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
  1259. extern int filp_close(struct file *, fl_owner_t id);
  1260. extern char * getname(const char __user *);
  1261.  
  1262. /* fs/dcache.c */
  1263. extern void __init vfs_caches_init_early(void);
  1264. extern void __init vfs_caches_init(unsigned long);
  1265.  
  1266. #define __getname()    kmem_cache_alloc(names_cachep, SLAB_KERNEL)
  1267. #define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
  1268. #ifndef CONFIG_AUDITSYSCALL
  1269. #define putname(name)   __putname(name)
  1270. #else
  1271. #define putname(name)                            \
  1272.     do {                                \
  1273.         if (unlikely(current->audit_context))            \
  1274.             audit_putname(name);                \
  1275.         else                            \
  1276.             __putname(name);                \
  1277.     } while (0)
  1278. #endif
  1279.  
  1280. extern int register_blkdev(unsigned int, const char *);
  1281. extern int unregister_blkdev(unsigned int, const char *);
  1282. extern struct block_device *bdget(dev_t);
  1283. extern void bd_set_size(struct block_device *, loff_t size);
  1284. extern void bd_forget(struct inode *inode);
  1285. extern void bdput(struct block_device *);
  1286. extern struct block_device *open_by_devnum(dev_t, unsigned);
  1287. extern struct file_operations def_blk_fops;
  1288. extern struct address_space_operations def_blk_aops;
  1289. extern struct file_operations def_chr_fops;
  1290. extern struct file_operations bad_sock_fops;
  1291. extern struct file_operations def_fifo_fops;
  1292. extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
  1293. extern int blkdev_ioctl(struct inode *, struct file *, unsigned, unsigned long);
  1294. extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
  1295. extern int blkdev_get(struct block_device *, mode_t, unsigned);
  1296. extern int blkdev_put(struct block_device *);
  1297. extern int bd_claim(struct block_device *, void *);
  1298. extern void bd_release(struct block_device *);
  1299.  
  1300. /* fs/char_dev.c */
  1301. extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
  1302. extern int register_chrdev_region(dev_t, unsigned, const char *);
  1303. extern int register_chrdev(unsigned int, const char *,
  1304.                struct file_operations *);
  1305. extern int unregister_chrdev(unsigned int, const char *);
  1306. extern void unregister_chrdev_region(dev_t, unsigned);
  1307. extern int chrdev_open(struct inode *, struct file *);
  1308.  
  1309. /* fs/block_dev.c */
  1310. #define BDEVNAME_SIZE    32    /* Largest string for a blockdev identifier */
  1311. extern const char *__bdevname(dev_t, char *buffer);
  1312. extern const char *bdevname(struct block_device *bdev, char *buffer);
  1313. extern struct block_device *lookup_bdev(const char *);
  1314. extern struct block_device *open_bdev_excl(const char *, int, void *);
  1315. extern void close_bdev_excl(struct block_device *);
  1316.  
  1317. extern void init_special_inode(struct inode *, umode_t, dev_t);
  1318.  
  1319. /* Invalid inode operations -- fs/bad_inode.c */
  1320. extern void make_bad_inode(struct inode *);
  1321. extern int is_bad_inode(struct inode *);
  1322.  
  1323. extern struct file_operations read_fifo_fops;
  1324. extern struct file_operations write_fifo_fops;
  1325. extern struct file_operations rdwr_fifo_fops;
  1326. extern struct file_operations read_pipe_fops;
  1327. extern struct file_operations write_pipe_fops;
  1328. extern struct file_operations rdwr_pipe_fops;
  1329.  
  1330. extern int fs_may_remount_ro(struct super_block *);
  1331.  
  1332. /*
  1333.  * return READ, READA, or WRITE
  1334.  */
  1335. #define bio_rw(bio)        ((bio)->bi_rw & (RW_MASK | RWA_MASK))
  1336.  
  1337. /*
  1338.  * return data direction, READ or WRITE
  1339.  */
  1340. #define bio_data_dir(bio)    ((bio)->bi_rw & 1)
  1341.  
  1342. extern int check_disk_change(struct block_device *);
  1343. extern int invalidate_inodes(struct super_block *);
  1344. extern int __invalidate_device(struct block_device *, int);
  1345. extern int invalidate_partition(struct gendisk *, int);
  1346. unsigned long invalidate_mapping_pages(struct address_space *mapping,
  1347.                     pgoff_t start, pgoff_t end);
  1348. unsigned long invalidate_inode_pages(struct address_space *mapping);
  1349. static inline void invalidate_remote_inode(struct inode *inode)
  1350. {
  1351.     if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
  1352.         S_ISLNK(inode->i_mode))
  1353.         invalidate_inode_pages(inode->i_mapping);
  1354. }
  1355. extern int invalidate_inode_pages2(struct address_space *mapping);
  1356. extern int write_inode_now(struct inode *, int);
  1357. extern int filemap_fdatawrite(struct address_space *);
  1358. extern int filemap_flush(struct address_space *);
  1359. extern int filemap_fdatawait(struct address_space *);
  1360. extern int filemap_write_and_wait(struct address_space *mapping);
  1361. extern void sync_supers(void);
  1362. extern void sync_filesystems(int wait);
  1363. extern void emergency_sync(void);
  1364. extern void emergency_remount(void);
  1365. extern int do_remount_sb(struct super_block *sb, int flags,
  1366.              void *data, int force);
  1367. extern sector_t bmap(struct inode *, sector_t);
  1368. extern int setattr_mask(unsigned int);
  1369. extern int notify_change(struct dentry *, struct iattr *);
  1370. extern int permission(struct inode *, int, struct nameidata *);
  1371. extern int generic_permission(struct inode *, int,
  1372.         int (*check_acl)(struct inode *, int));
  1373.  
  1374. extern int get_write_access(struct inode *);
  1375. extern int deny_write_access(struct file *);
  1376. static inline void put_write_access(struct inode * inode)
  1377. {
  1378.     atomic_dec(&inode->i_writecount);
  1379. }
  1380. static inline void allow_write_access(struct file *file)
  1381. {
  1382.     if (file)
  1383.         atomic_inc(&file->f_dentry->d_inode->i_writecount);
  1384. }
  1385. extern int do_pipe(int *);
  1386.  
  1387. extern int open_namei(const char *, int, int, struct nameidata *);
  1388. extern int may_open(struct nameidata *, int, int);
  1389.  
  1390. extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
  1391. extern struct file * open_exec(const char *);
  1392.  
  1393. /* fs/dcache.c -- generic fs support functions */
  1394. extern int is_subdir(struct dentry *, struct dentry *);
  1395. extern ino_t find_inode_number(struct dentry *, struct qstr *);
  1396.  
  1397. #include <linux/err.h>
  1398.  
  1399. /* needed for stackable file system support */
  1400. extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
  1401.  
  1402. extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
  1403.  
  1404. extern void inode_init_once(struct inode *);
  1405. extern void iput(struct inode *);
  1406. extern struct inode * igrab(struct inode *);
  1407. extern ino_t iunique(struct super_block *, ino_t);
  1408. extern int inode_needs_sync(struct inode *inode);
  1409. extern void generic_delete_inode(struct inode *inode);
  1410.  
  1411. extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
  1412.         int (*test)(struct inode *, void *), void *data);
  1413. extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
  1414.  
  1415. extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
  1416. extern struct inode * iget_locked(struct super_block *, unsigned long);
  1417. extern void unlock_new_inode(struct inode *);
  1418.  
  1419. static inline struct inode *iget(struct super_block *sb, unsigned long ino)
  1420. {
  1421.     struct inode *inode = iget_locked(sb, ino);
  1422.     
  1423.     if (inode && (inode->i_state & I_NEW)) {
  1424.         sb->s_op->read_inode(inode);
  1425.         unlock_new_inode(inode);
  1426.     }
  1427.  
  1428.     return inode;
  1429. }
  1430.  
  1431. extern void __iget(struct inode * inode);
  1432. extern void clear_inode(struct inode *);
  1433. extern void destroy_inode(struct inode *);
  1434. extern struct inode *new_inode(struct super_block *);
  1435. extern int remove_suid(struct dentry *);
  1436. extern void remove_dquot_ref(struct super_block *, int, struct list_head *);
  1437. extern struct semaphore iprune_sem;
  1438.  
  1439. extern void __insert_inode_hash(struct inode *, unsigned long hashval);
  1440. extern void remove_inode_hash(struct inode *);
  1441. static inline void insert_inode_hash(struct inode *inode) {
  1442.     __insert_inode_hash(inode, inode->i_ino);
  1443. }
  1444.  
  1445. extern struct file * get_empty_filp(void);
  1446. extern void file_move(struct file *f, struct list_head *list);
  1447. extern void file_kill(struct file *f);
  1448. struct bio;
  1449. extern void submit_bio(int, struct bio *);
  1450. extern int bdev_read_only(struct block_device *);
  1451. extern int set_blocksize(struct block_device *, int);
  1452. extern int sb_set_blocksize(struct super_block *, int);
  1453. extern int sb_min_blocksize(struct super_block *, int);
  1454.  
  1455. extern int generic_file_mmap(struct file *, struct vm_area_struct *);
  1456. extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
  1457. extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
  1458. extern int file_send_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
  1459. extern ssize_t generic_file_read(struct file *, char __user *, size_t, loff_t *);
  1460. int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
  1461. extern ssize_t generic_file_write(struct file *, const char __user *, size_t, loff_t *);
  1462. extern ssize_t generic_file_aio_read(struct kiocb *, char __user *, size_t, loff_t);
  1463. extern ssize_t __generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t *);
  1464. extern ssize_t generic_file_aio_write(struct kiocb *, const char __user *, size_t, loff_t);
  1465. extern ssize_t generic_file_aio_write_nolock(struct kiocb *, const struct iovec *,
  1466.         unsigned long, loff_t *);
  1467. extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
  1468.         unsigned long *, loff_t, loff_t *, size_t, size_t);
  1469. extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
  1470.         unsigned long, loff_t, loff_t *, size_t, ssize_t);
  1471. extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
  1472. extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
  1473. ssize_t generic_file_write_nolock(struct file *file, const struct iovec *iov,
  1474.                 unsigned long nr_segs, loff_t *ppos);
  1475. extern ssize_t generic_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *);
  1476. extern void do_generic_mapping_read(struct address_space *mapping,
  1477.                     struct file_ra_state *, struct file *,
  1478.                     loff_t *, read_descriptor_t *, read_actor_t);
  1479. extern void
  1480. file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
  1481. extern ssize_t generic_file_direct_IO(int rw, struct kiocb *iocb,
  1482.     const struct iovec *iov, loff_t offset, unsigned long nr_segs);
  1483. extern ssize_t generic_file_readv(struct file *filp, const struct iovec *iov, 
  1484.     unsigned long nr_segs, loff_t *ppos);
  1485. ssize_t generic_file_writev(struct file *filp, const struct iovec *iov, 
  1486.             unsigned long nr_segs, loff_t *ppos);
  1487. extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
  1488. extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
  1489. extern loff_t remote_llseek(struct file *file, loff_t offset, int origin);
  1490. extern int generic_file_open(struct inode * inode, struct file * filp);
  1491. extern int nonseekable_open(struct inode * inode, struct file * filp);
  1492.  
  1493. static inline void do_generic_file_read(struct file * filp, loff_t *ppos,
  1494.                     read_descriptor_t * desc,
  1495.                     read_actor_t actor)
  1496. {
  1497.     do_generic_mapping_read(filp->f_mapping,
  1498.                 &filp->f_ra,
  1499.                 filp,
  1500.                 ppos,
  1501.                 desc,
  1502.                 actor);
  1503. }
  1504.  
  1505. ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
  1506.     struct block_device *bdev, const struct iovec *iov, loff_t offset,
  1507.     unsigned long nr_segs, get_blocks_t get_blocks, dio_iodone_t end_io,
  1508.     int lock_type);
  1509.  
  1510. enum {
  1511.     DIO_LOCKING = 1, /* need locking between buffered and direct access */
  1512.     DIO_NO_LOCKING,  /* bdev; no locking at all between buffered/direct */
  1513.     DIO_OWN_LOCKING, /* filesystem locks buffered and direct internally */
  1514. };
  1515.  
  1516. static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
  1517.     struct inode *inode, struct block_device *bdev, const struct iovec *iov,
  1518.     loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
  1519.     dio_iodone_t end_io)
  1520. {
  1521.     return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
  1522.                 nr_segs, get_blocks, end_io, DIO_LOCKING);
  1523. }
  1524.  
  1525. static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
  1526.     struct inode *inode, struct block_device *bdev, const struct iovec *iov,
  1527.     loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
  1528.     dio_iodone_t end_io)
  1529. {
  1530.     return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
  1531.                 nr_segs, get_blocks, end_io, DIO_NO_LOCKING);
  1532. }
  1533.  
  1534. static inline ssize_t blockdev_direct_IO_own_locking(int rw, struct kiocb *iocb,
  1535.     struct inode *inode, struct block_device *bdev, const struct iovec *iov,
  1536.     loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
  1537.     dio_iodone_t end_io)
  1538. {
  1539.     return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
  1540.                 nr_segs, get_blocks, end_io, DIO_OWN_LOCKING);
  1541. }
  1542.  
  1543. extern struct file_operations generic_ro_fops;
  1544.  
  1545. #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
  1546.  
  1547. extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
  1548. extern int vfs_follow_link(struct nameidata *, const char *);
  1549. extern int page_readlink(struct dentry *, char __user *, int);
  1550. extern int page_follow_link_light(struct dentry *, struct nameidata *);
  1551. extern void page_put_link(struct dentry *, struct nameidata *);
  1552. extern int page_symlink(struct inode *inode, const char *symname, int len);
  1553. extern struct inode_operations page_symlink_inode_operations;
  1554. extern int generic_readlink(struct dentry *, char __user *, int);
  1555. extern void generic_fillattr(struct inode *, struct kstat *);
  1556. extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
  1557. void inode_add_bytes(struct inode *inode, loff_t bytes);
  1558. void inode_sub_bytes(struct inode *inode, loff_t bytes);
  1559. loff_t inode_get_bytes(struct inode *inode);
  1560. void inode_set_bytes(struct inode *inode, loff_t bytes);
  1561.  
  1562. extern int vfs_readdir(struct file *, filldir_t, void *);
  1563.  
  1564. extern int vfs_stat(char __user *, struct kstat *);
  1565. extern int vfs_lstat(char __user *, struct kstat *);
  1566. extern int vfs_fstat(unsigned int, struct kstat *);
  1567.  
  1568. extern int vfs_ioctl(struct file *, unsigned int, unsigned int, unsigned long);
  1569.  
  1570. extern struct file_system_type *get_fs_type(const char *name);
  1571. extern struct super_block *get_super(struct block_device *);
  1572. extern struct super_block *user_get_super(dev_t);
  1573. extern void drop_super(struct super_block *sb);
  1574.  
  1575. extern int dcache_dir_open(struct inode *, struct file *);
  1576. extern int dcache_dir_close(struct inode *, struct file *);
  1577. extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
  1578. extern int dcache_readdir(struct file *, void *, filldir_t);
  1579. extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
  1580. extern int simple_statfs(struct super_block *, struct kstatfs *);
  1581. extern int simple_link(struct dentry *, struct inode *, struct dentry *);
  1582. extern int simple_unlink(struct inode *, struct dentry *);
  1583. extern int simple_rmdir(struct inode *, struct dentry *);
  1584. extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
  1585. extern int simple_sync_file(struct file *, struct dentry *, int);
  1586. extern int simple_empty(struct dentry *);
  1587. extern int simple_readpage(struct file *file, struct page *page);
  1588. extern int simple_prepare_write(struct file *file, struct page *page,
  1589.             unsigned offset, unsigned to);
  1590. extern int simple_commit_write(struct file *file, struct page *page,
  1591.                 unsigned offset, unsigned to);
  1592.  
  1593. extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
  1594. extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
  1595. extern struct file_operations simple_dir_operations;
  1596. extern struct inode_operations simple_dir_inode_operations;
  1597. struct tree_descr { char *name; struct file_operations *ops; int mode; };
  1598. struct dentry *d_alloc_name(struct dentry *, const char *);
  1599. extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
  1600. extern int simple_pin_fs(char *name, struct vfsmount **mount, int *count);
  1601. extern void simple_release_fs(struct vfsmount **mount, int *count);
  1602.  
  1603. extern ssize_t simple_read_from_buffer(void __user *, size_t, loff_t *, const void *, size_t);
  1604.  
  1605. extern int inode_change_ok(struct inode *, struct iattr *);
  1606. extern int __must_check inode_setattr(struct inode *, struct iattr *);
  1607.  
  1608. extern void inode_update_time(struct inode *inode, int ctime_too);
  1609.  
  1610. static inline ino_t parent_ino(struct dentry *dentry)
  1611. {
  1612.     ino_t res;
  1613.  
  1614.     spin_lock(&dentry->d_lock);
  1615.     res = dentry->d_parent->d_inode->i_ino;
  1616.     spin_unlock(&dentry->d_lock);
  1617.     return res;
  1618. }
  1619.  
  1620. /* kernel/fork.c */
  1621. extern int unshare_files(void);
  1622.  
  1623. /* Transaction based IO helpers */
  1624.  
  1625. /*
  1626.  * An argresp is stored in an allocated page and holds the
  1627.  * size of the argument or response, along with its content
  1628.  */
  1629. struct simple_transaction_argresp {
  1630.     ssize_t size;
  1631.     char data[0];
  1632. };
  1633.  
  1634. #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
  1635.  
  1636. char *simple_transaction_get(struct file *file, const char __user *buf,
  1637.                 size_t size);
  1638. ssize_t simple_transaction_read(struct file *file, char __user *buf,
  1639.                 size_t size, loff_t *pos);
  1640. int simple_transaction_release(struct inode *inode, struct file *file);
  1641.  
  1642. static inline void simple_transaction_set(struct file *file, size_t n)
  1643. {
  1644.     struct simple_transaction_argresp *ar = file->private_data;
  1645.  
  1646.     BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
  1647.  
  1648.     /*
  1649.      * The barrier ensures that ar->size will really remain zero until
  1650.      * ar->data is ready for reading.
  1651.      */
  1652.     smp_mb();
  1653.     ar->size = n;
  1654. }
  1655.  
  1656. #ifdef CONFIG_SECURITY
  1657. static inline char *alloc_secdata(void)
  1658. {
  1659.     return (char *)get_zeroed_page(GFP_KERNEL);
  1660. }
  1661.  
  1662. static inline void free_secdata(void *secdata)
  1663. {
  1664.     free_page((unsigned long)secdata);
  1665. }
  1666. #else
  1667. static inline char *alloc_secdata(void)
  1668. {
  1669.     return (char *)1;
  1670. }
  1671.  
  1672. static inline void free_secdata(void *secdata)
  1673. { }
  1674. #endif    /* CONFIG_SECURITY */
  1675.  
  1676. #endif /* __KERNEL__ */
  1677. #endif /* _LINUX_FS_H */
  1678.